/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package jxta;

import atributos.Atributo;
import atributos.ManagerAtributos;
import exclusionmutua.ExclusionMutua;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import net.jxta.endpoint.Message;
import net.jxta.pipe.InputPipe;
import net.jxta.pipe.OutputPipe;
import net.jxta.pipe.PipeService;
import net.jxta.protocol.PipeAdvertisement;
import utilidades.AdminMensaje;
import utilidades.ConsultaAdvertisement;

/**
 *
 * @author kastillo
 */
public class ProcesarConsultas {

    public final static String SEP = ";";
    private PipeService pipeService;
    private PipeAdvertisement pipeAdv;
    private CrearOutputPipe crearOutputPipe;
    private ManagerAtributos mgrAtt;
    private String consulta;
    private Integer tipoQuery;
    private PipeAdvertisement remotePipe;
    private ArrayList<Atributo> respAtt;
    private Message msj;
    private final PipeAdvertisement pipedeDescarga;
    private Map<String, ExclusionMutua> exclusionMutuaMap;
    private PipeAdvertisement pipeEM;
    private String nombrePeer;
    private boolean isConsultaParaToken;

    public ProcesarConsultas(PipeService pipeService, 
            PipeAdvertisement pipe,
            PipeAdvertisement pipedeDescarga,
            Map<String, ExclusionMutua> exclusionMutuaMap,
            PipeAdvertisement pipeEM,
            String nombrePeer
            ) {

        this.pipeService = pipeService;
        this.pipeAdv = pipe;
        System.out.println("verificando la ruta " + ManagerAtributos.PATH);
        this.mgrAtt = new ManagerAtributos(ManagerAtributos.PATH);
        this.pipedeDescarga = pipedeDescarga;
        this.exclusionMutuaMap = exclusionMutuaMap;
        this.pipeEM = pipeEM;
        this.nombrePeer = nombrePeer;
    }



    void manipularAdvertisement(ConsultaAdvertisement adv) {
        isConsultaParaToken = false;
        System.out.println("procesando Consulta");
        procesar(adv);
        responder();

    }

    private void responder() {
        if(!isConsultaParaToken){
        System.out.println("respondiendo consulta");
        crearOutputPipe = new CrearOutputPipe(pipeService, pipeAdv, msj,null,0);
        Thread crearPipe = new Thread(crearOutputPipe);
        crearPipe.start();
        }
    }

    private void procesar(ConsultaAdvertisement adv) {
        try {
            System.out.println("Manejando una nueva petición de un nodo remoto");
            consulta = adv.getQuery();
            tipoQuery = adv.getTipoQuery();
            remotePipe = adv.getPipe();

            switch (tipoQuery) {
                case ConsultaAdvertisement.QUERY_POR_ID:
                    respAtt = mgrAtt.Consulta(ConsultaAdvertisement.QUERY_POR_ID, consulta,nombrePeer);
                    msj = AdminMensaje.crearRespuestaMensaje(respAtt, pipedeDescarga,
                            AdminMensaje.NAME_SPACE);
                    break;
                case ConsultaAdvertisement.QUERY_POR_KEYWORDS:
                    respAtt = mgrAtt.Consulta(ConsultaAdvertisement.QUERY_POR_KEYWORDS,consulta,nombrePeer);
                    msj = AdminMensaje.crearRespuestaMensaje(respAtt, pipedeDescarga,
                            AdminMensaje.NAME_SPACE);
                    break;
                case ConsultaAdvertisement.QUERY_POR_KPARECIDOS:
                    respAtt = mgrAtt.Consulta(ConsultaAdvertisement.QUERY_POR_KPARECIDOS,consulta,nombrePeer);
                    msj = AdminMensaje.crearRespuestaMensaje(respAtt, pipedeDescarga,
                            AdminMensaje.NAME_SPACE);
                    break;
                case ConsultaAdvertisement.ESTADO:
                    respAtt = CrearInputPipe.getResultados();
                    ManagerJXTA.estadoGlobal.setColor("ROJO");
                    msj = AdminMensaje.crearRespuestaMensaje(respAtt, pipedeDescarga,
                            AdminMensaje.NAME_SPACE);
                    break;                    

                case ConsultaAdvertisement.QUERY_POR_TODOS:


                    
                  //  ManagerJXTA.historiaMensajes

                    System.out.println("====================EXCLUSIÓN MUTUA=======================");
                    System.out.println("=====RESOLVIENDO CONSULTAS DE QUE ARCHIVOS TENGO==========");
                    respAtt = mgrAtt.Consulta(ConsultaAdvertisement.QUERY_POR_TODOS, consulta,nombrePeer);
                    msj = AdminMensaje.crearRespuestaMensaje(respAtt, pipeEM,
                            AdminMensaje.NAME_SPACE);
                    break;

                case ConsultaAdvertisement.REQUESTING_CS:

                    isConsultaParaToken = true;

                    System.out.println("====================EXCLUSIÓN MUTUA=======================");
                    System.out.println("=====MANEJANDO PETICIÓN DE SECCION CRITICA DE NODO REMOTO=");

                    int beginId = consulta.indexOf(AdminMensaje.ID_DOCUMENTO_TAG)
                            + AdminMensaje.ID_DOCUMENTO_TAG.length();
                    int endId = consulta.indexOf(SEP, beginId);
                    String idDocumento = consulta.substring(beginId, endId);
                    System.out.println("IdDocument: " + idDocumento);


                    int beginSeqNumb = consulta.indexOf(AdminMensaje.SEQ_NUMB_TAG) +
                            AdminMensaje.SEQ_NUMB_TAG.length();
                    int endSeqNumb = consulta.indexOf(SEP, beginSeqNumb);
                    String seqNumb = consulta.substring(beginSeqNumb, endSeqNumb);
                    System.out.println("Numero de Sequencia: " + seqNumb);

                    int beginSecuencia = consulta.indexOf(AdminMensaje.NUM_SEC) +
                            AdminMensaje.NUM_SEC.length();
                    int endSecuencia = consulta.indexOf(SEP, beginSecuencia);
                    int numeroSecuencia = Integer.parseInt(consulta.substring(beginSecuencia, endSecuencia));
                    System.out.println("Numero de Sequencia de : " + numeroSecuencia);

                    int beginOrigen = consulta.indexOf(AdminMensaje.NODO_ORIGEN) +
                            AdminMensaje.NODO_ORIGEN.length();
                    int endOrigen = consulta.indexOf(SEP, beginOrigen);
                    String origen = consulta.substring(beginOrigen, endOrigen);
                    System.out.println("Numero de Sequencia de : " + origen);
                    
                    int beginColor = consulta.indexOf(AdminMensaje.COLOR) +
                            AdminMensaje.COLOR.length();
                    int endColor = consulta.indexOf(SEP, beginColor);
                    String color = consulta.substring(beginColor, endColor);
                    System.out.println("Numero de Sequencia de : " + color);


                      
                              



                    ManagerJXTA.historiaMensajes.guardarMensajeRecibido(numeroSecuencia, origen, consulta, color);

                    String destino = origen;
                    int secuencia = numeroSecuencia;
                    
                    ExclusionMutua em = exclusionMutuaMap.get(idDocumento);
                    em.receiveRequest(remotePipe, new Integer(seqNumb),destino,secuencia);
                    System.out.println("Gestionada solicitud de petición de SC");
                    break;
                default:
                    System.out.println("El advertisement contiene un tipo invalido");
                    return;
            }





        } catch (IOException ex) {
            Logger.getLogger(ProcesarConsultas.class.getName()).log(Level.SEVERE,
                    "Error en la creación del mensaje de respuesta a consulta", ex);
        }




    }
}
